﻿// ConsoleApplication1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
using namespace std;
#include "PublicTempTest.h"

#include "SuoerCamera.h"
#include "SuoerUSB3Camera.hpp"
#include "FTD3XXStream.h"
#include "FTD3XXDevice.h"
#include "LibUSBFT601Device.h"
#include "LibUSBFT601Stream.h"

//#pragma comment(lib,"powrprof.lib")
////#include <windows.h>
//#include <powrprof.h>

int main()
{
	std::cout << "Hello World!\n";

	//行指针
	if (false)
	{
		int array2[3][5];
		for (int i = 0; i < 3; i++)
		{
			for (int j = 0; j < 5; j++)
			{
				array2[i][j] = i * 5 + j;
			}
		}

		for (int i = 0; i < 3; i++)
		{
			for (int j = 0; j < 5; j++)
			{
				std::cout << array2[i][j] << "\t";
			}

			std::cout << std::endl;
		}

		int* pp1 = array2[1];//行地址
		std::cout << *(pp1++) << std::endl;
		std::cout << *(pp1++) << std::endl;
		std::cout << *(pp1++) << std::endl;
		std::cout << *(pp1++) << std::endl;
		std::cout << *(pp1++) << std::endl;
		std::cout << *(pp1++) << std::endl;
	}

	//栈和堆
	if (false)
	{
		// 栈和堆的主要区别:
		// 1、管理方式不同:栈是编译器自动管理的，在出作用域时，将自动被释放。堆需手动释放，若程序中不释放，程序结束时由操作系统回收。
		// 2、空间大小不同:堆内存的大小受限于物理内存空间；而栈就小得可怜，一般只有8M(可以修改系统参数)。
		// 3、分配方式不同:堆是动态分配；栈有静态分配和动态分配(都是自动释放)。
		// 4、分配效率不同:栈是系统提供的数据结构，计算机在底层提供了对栈的支持，进栈和出栈有专门的指令，效率比较高;堆是由C++函数库提供的。
		// 5、是否产生碎片:对于栈来说，进栈和出都有着严格的顺序(先进后出)，不会产生碎片，而堆频繁的分配和释放，会造成内存空间的不连续，容易产生碎片，太多的碎片会导致性能的下降。
		// 6、增长方向不同:栈向下增长，以降序分配内存地址，堆上增长，以升序分配内存地址
		{
			//      // int* a=new int(10); //堆
			//      for (int i = 1; i > 0; i++) {
			//        int *p = new int[100000];  // 动态分配内存--保存在堆
			//        cout << "i:" << i << ", *p" << p << endl;
			//        delete p;  // 手动回收---指定的内存空间回收；
			//      }
			int* p = new int(10);
			cout << "*p" << *p << endl;
			*p = 20;
			cout << "*p" << *p << endl;
			delete p;
			// 1.动态分配出来的内存没有变量名，只能通过指向它的指针来操作内存中的数据;
			// 2.如果动态分配的内存不用了，必须用delete释放它,否则有可能用尽系统的内存。
		}
	}

	// 目的：在方法内部动态分配内存，然后在使用完之后，要把动态分配的内存给释放回收掉
	if (false)
	{
		cout << "方法外定义的堆区~" << endl;
		int* p = new int(0);  // p 在这里动态分配内存 #################
		cout << "p的值(也就是动态分配的内存地址)：" << p << ",*p=" << *p << "，p的地址：" << &p << endl;
		// 如果业务要求，声明指针的代码，分配内存的代码在另外一个函数中；
		auto ppshow = [](int* px)
			{
				cout << endl;
				cout << "进入lambda 表达式ppshow==================" << endl;
				cout << "px的值：" << px << ",*px=" << *px << "，px的地址：" << &px << endl;
				int* pp = new int(200);  // 修改指针指向的地址；
				cout << "pp的值：" << pp << ",*pp=" << *pp << "，pp的地址：" << &pp << endl;
				*px = *pp;  // 就可以对外部传递过来的指针指向的值做改变；
				return pp;
			};

		int* pr = ppshow(p);
		cout << "lambda 表达式ppshow 执行完成==================" << endl;
		cout << "p=" << p << ",*p=" << *p << "，p的地址：" << &p << endl;
		cout << "pr=" << pr << ",*pr=" << *pr << "，pr的地址：" << &pr << endl;

		delete pr;
		delete p;  // 释放的是p #################
		// 如何证明是释放了？？
		cout << *pr << endl;
		cout << *p << endl;
	}

	//数组的引用
	if (false)
	{
		cout << "引用数组的语法：" << endl;
		// 1. ArrRef & 引用的名称=数组的名称；
		// 2. 数据类型（&引用名称）[数组的长度]=数组名称；
		cout << "建立数组引用方法一" << endl;
		{
			int arr[10] = {};

			typedef int ArrRef[10];
			ArrRef& aRef = arr;  // aRef是数组arr的引用；

			cout << endl;
			cout << "遍历赋值-操作aRef================" << endl;
			for (int i = 0; i < 10; i++)
			{
				aRef[i] = i + 1;
			}
			cout << endl;
			cout << "遍历取值-取arr================" << endl;
			for (int item : arr)
			{
				cout << item << endl;
			}
		}
		cout << endl;
		cout << "=========================" << endl;
		cout << "=========================" << endl;
		cout << "=========================" << endl;
		cout << "建立数组引用方法二" << endl;
		{
			int arr1[10] = {};  // 这是声明数组

			for (int item : arr1)
			{
				cout << item << endl;
			}

			int(&aRef)[10] = arr1;  // 声明引用，声明引用必须要赋值；
			// aRef是数组arr1的引用； cout << endl;
			cout << "遍历赋值-操作aRef================" << endl;
			for (int i = 0; i < 10; i++)
			{
				aRef[i] = i + 21;
			}
			cout << endl;
			cout << "遍历取值-取arr================" << endl;
			for (int item : arr1)
			{
				cout << item << endl;
			}
		}
	}

	if (false)
	{
		SuoerCamera* suoer_camera = new SuoerUSB3Camera<FTD3XXStream, FTD3XXDevice>();
		if (suoer_camera->open("FTD3XX"))
		{
			suoer_camera->startGrab();
			suoer_camera->stopGrab();
			suoer_camera->close();
		}
		delete suoer_camera;
		suoer_camera = nullptr;
	}
	if (false)
	{
		SuoerCamera* suoer_camera = new SuoerUSB3Camera<LibUSBFT601Stream, LibUSBFT601Device>();
		if (suoer_camera->open("LibUSBFT601"))
		{
			suoer_camera->startGrab();
			suoer_camera->stopGrab();
			suoer_camera->close();
		}
		delete suoer_camera;
		suoer_camera = nullptr;
	}
	if (false)
	{
		/*double cct = std::numeric_limits<double>::quiet_NaN();
		double CCT = std::max(0.0, cct);
		cct = 1.5;
		CCT = std::max(0.0, cct);
		cout << "调用：SwapExtNew(double& u1, double& u2)";*/
	}


	/*SetPowerScheme(1);
	std::this_thread::sleep_for(std::chrono::seconds(30));
	SetPowerScheme(2);
	std::this_thread::sleep_for(std::chrono::seconds(30));
	SetPowerScheme(1);*/
}

//const GUID scheme1 = { 0x8C5E7FDA, 0xE8BF, 0x4A96, { 154, 133, 166, 226, 58, 140, 99, 92 } };//高性能
//const GUID scheme2 = { 0x381B4222, 0xF694, 0x41F0, { 150, 133, 255, 91, 178, 96, 223, 46 } };//平衡
//const GUID scheme3 = { 0xA1841308, 0x3541, 0x4FAB, { 188, 129, 247, 21, 86, 242, 11, 74 } };//节能
//
////设置电源计划
//bool SetPowerScheme(int scheme)
//{
//	if (scheme == 1)
//	{
//		return (ERROR_SUCCESS == PowerSetActiveScheme(NULL, &scheme1));
//	}
//	if (scheme == 2)
//	{
//		return (ERROR_SUCCESS == PowerSetActiveScheme(NULL, &scheme2));
//	}
//	if (scheme == 3)
//	{
//		return (ERROR_SUCCESS == PowerSetActiveScheme(NULL, &scheme3));
//	}
//	return false;
//}


// 普通函数的实现
void SwapExtNew(double& u1, double& u2)
{
	double x = u1;
	u1 = u2;
	u2 = x;
	cout << "调用：SwapExtNew(double& u1, double& u2)";
}

// 模板函数
template <typename T, typename A> void SwapExtNew(T& a, A& b) {
	T x = a;
	a = b;
	b = x;
	cout << "调用：SwapExtNew(T& a, A& b)";
};
// 模板函数的具体化
template<> void SwapExtNew(User& u1, User& u2)
{
	string gift1 = u1.gift;
	u1.gift = u2.gift;
	u2.gift = gift1;
	cout << "调用：SwapExtNew<user,user>(user& u1,user& u2)";
}

